home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / gle / pass.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-29  |  27.2 KB  |  1,040 lines
  1. #include "all.h"
  2.  
  3. #include "global.h"
  4. #include "proto.h"
  5.  
  6. long gt_index(OPKEY lkey,char *s);
  7. int include_file(char *s);
  8. int var_set_local(void);
  9. int var_set_global(void);
  10. int var_clear_local(void);
  11. int get_cap(TOKENS tk,int *ntok,int *curtok,long *pcode,int *plen);
  12. int get_join(TOKENS tk,int *ntok,int *curtok,long *pcode,int *plen);
  13. int g_marker_def(char *s1, char *s2);
  14. extern int this_line;
  15.  
  16. #define true (!false)
  17. #define false 0
  18. #define tok(n)  (*tk)[n]
  19. extern int gle_debug;
  20.  
  21. struct sub_st {char name[40];int typ; int np
  22.         ; int ptyp[20]; char *pname[20]; }  ;
  23. struct sub_st *psub;
  24. /*---------------------------------------------------------------------------*/
  25. #define no_more()  if (curtok<=*ntok) gprint("Unexpected text on end of command {%s}\n",tok(curtok));
  26. #define lkeypos(i)  (pcode + *plen + (*lkey)[i].pos - 1);
  27. #define dup_err if (*pt!=0) gprint("Duplicate or illegal combination of qualifiers \n");
  28. #define get_xy() gt_xy(&curtok,tk,ntok,pcode,plen)
  29. #define get_first(key) gt_first((OPKEY) key,&curtok,(TOKENS) tk,ntok,pcode,plen)
  30. #define get_optional(key) gt_optional((OPKEY) key,&curtok,(TOKENS) tk,ntok,pcode,plen)
  31. #define skip_space  if (*tok(curtok)==' ') {curtok++;}
  32. #define get_anyexp() {etype=0;polish(tok(curtok++),(char *) pcode,plen,&etype);}
  33. #define get_exp() {etype=1;polish(tok(curtok++),(char *) pcode,plen,&etype);}
  34. #define get_strexp() {etype=2;polish(tok(curtok++),(char *) pcode,plen,&etype);}
  35. #define get_token(t) if (strcmp(t,tok(curtok))!=0) gprint("Expecting {%s} found {%s} %d \n",t,tok(curtok),curtok); curtok += 1
  36. #define dbg if ((gle_debug & 8)>0)
  37.  
  38. /* pos=   Offset to find the data            */
  39. /* idx=   For switches, which can only have one value.     */
  40. /* The pos is the order the items will be placed in the pcode */
  41. /*---------------------------------------------------------------------------*/
  42. /* Input is gle command (tokized) , output is pcode */
  43. static int cur_mode=0;  /* 0 = normal, 1 = external begin...end */
  44. pass_checkmode()
  45. {
  46.     if (cur_mode!=0) gprint("END OF FILE while in block type %d \n",cur_mode);
  47.     cur_mode = 0; /* reset it */
  48. }
  49. passt(int srclin,char *source,TOKENS tk,int *ntok,long *pcode,int *plen)
  50. {
  51.         /* Source line number */
  52.         /* a pointer to the original string */
  53.         /* a pointer to an array of 500 pointers to char tokens */
  54.         /* pinter to number of tokens */
  55.         /* a pointer to the pcode output buffer */
  56.         /* a pointer to the length of the pcode output */
  57. int etype;
  58. static int sdx;
  59. static int sub_start,sub_end;
  60. static char tempstr[300];
  61. static char *sp;
  62. static int *savep;
  63. static int i,f,vtyp,v,sl,np,in_sub,vidx,vtype;
  64.     int ix;
  65.     int curtok=1;
  66.  
  67.     vtype = 0;
  68.     this_line = srclin;
  69.     etype = 1;
  70.     curtok = 1;
  71.     if (cur_mode!=0) {goto text_mode;}
  72.  
  73.     dbg for (i=1;i<= *ntok; i++) gprint("{%s}%d ",tok(i),strlen(tok(i)));
  74.     dbg gprint("\n");
  75.  
  76.     if (*ntok==0) { /* blank line */
  77.         *(pcode+(*plen)++) = 0;
  78.         return;
  79.     }
  80.     find_mkey(tok(1),&ix);
  81.     if (ix==0) {
  82.         if (*tok(1)=='@') { /* call subroutine */
  83.             char tmpexp[232];
  84.             *(pcode+(*plen)++) = 52;
  85.             curtok = 2;
  86.             strcpy(tmpexp,tok(1)+1);
  87.             strcat(tmpexp,"(");
  88.             if (curtok > *ntok) strcat(tmpexp,",");
  89.             while (curtok <= *ntok) {
  90.                 strcat(tmpexp,tok(curtok++));
  91.                 strcat(tmpexp,",");
  92.             }
  93.             tmpexp[strlen(tmpexp)-1] = ')';
  94.             etype = 0;
  95.             polish(tmpexp,(char *) pcode,plen,&etype);
  96.             return ;
  97.         }
  98.         if (strcmp(tok(2),"=")==0) {  /* variable = expression */
  99.             *(pcode+(*plen)++) = 51;
  100.             var_find(tok(1),&vidx,&vtype);
  101.             if (vidx<0) var_add(tok(1),&vidx,&vtype);
  102.             *(pcode+(*plen)++) = vidx;
  103.             curtok = 3;
  104.             polish(tok(curtok++),(char *) pcode,plen,&vtype);
  105.             if (*ntok >= curtok)  gprint("Remove spaces from expression \n");
  106.             return ;
  107.         }
  108.         sp = strchr(tok(curtok),'=');
  109.         if (sp!=NULL) {
  110.             *sp = 0;
  111.             var_findadd(tok(curtok),&vidx,&vtype);
  112.             tok(curtok) = sp + 1;
  113.             *(pcode+(*plen)++) = 51;
  114.             *(pcode+(*plen)++) = vidx;
  115.             curtok = 1;
  116.             polish(tok(curtok++),(char *) pcode,plen,&vtype);
  117.             if (*ntok >= curtok)  gprint("No spaces in expressions\n");
  118.             return ;
  119.         }
  120.     }
  121.     *(pcode+(*plen)++) = ix;
  122.     curtok = 2;
  123.     switch (ix) {
  124.       case 1:  /* ALINE */
  125.         get_xy();
  126.         get_optional(op_line);
  127.         break;
  128.       case 2: /* AMOVE */
  129.         get_xy();
  130.         break;
  131.       case 3: /* ARC r a1 a2  */
  132.         get_exp();
  133.         get_xy();
  134.         no_more();
  135.         break;
  136.       case 4: /* ARCTO x1 y1 x2 y2 r */
  137.         get_xy();
  138.         get_xy();
  139.         get_exp();
  140.         no_more();
  141.         break;
  142.       case 5: /* BEGIN  "PATH"  "BOX"  "SCALE"  "ROTATE"  "TRANSLATE" */
  143.         f = get_first(op_begin);
  144.         *(pcode+(*plen)++) = f;
  145.         spush(51);
  146.         /*------------------------------------------*/
  147.         /*       Check if begin variable matches    */
  148.         /*------------------------------------------*/
  149.         switch (f) {
  150.           case 1: /* path */
  151.             get_optional(op_begin_path);
  152.             break;
  153.           case 2: /* box */
  154.             get_optional(op_begin_box);
  155.             break;
  156.           case 3: /* scale */
  157.             get_xy();
  158.             /* get_optional(op_begin_scale); */
  159.             no_more();
  160.             break;
  161.           case 4: /* rotate */
  162.             get_exp();
  163.             /* get_optional(op_begin_scale); */
  164.             no_more();
  165.             break;
  166.           case 5: /* translate */
  167.             get_xy();
  168. /*            get_optional(op_begin_scale); */
  169.             no_more();
  170.             break;
  171.           case 19: /* clip */
  172.           case 17: /* origin */
  173.             break;
  174.           case 6: /* if */
  175.             break;
  176.           case 7: /* sub */
  177.             gprint("Not a valid begin option\n");
  178.             break;
  179.           case 8: /* name joe */
  180.             get_strexp();
  181.             break;
  182.           case 9: /* text */
  183.             cur_mode = 9;
  184.             get_optional(op_begin_text);
  185.             break;
  186.           case 10: /* graph */
  187.             cur_mode = 10;
  188.             break;
  189.           case 11: /* xaxis */
  190.             cur_mode = 11;
  191.             break;
  192.           case 12: /* yaxis */
  193.             cur_mode = 12;
  194.             break;
  195.           case 13: /* x2axis */
  196.             cur_mode = 13;
  197.             break;
  198.           case 14: /* y2axis */
  199.             cur_mode = 14;
  200.             break;
  201.           case 15: /* curve */
  202.             break;
  203.           case 16: /* KEY */
  204.             cur_mode = 16;
  205.             break;
  206.           case 18: /* table */
  207.             cur_mode = 18;
  208.             break;
  209.         }
  210.         /* here should copy source line across for "begin width 3 */
  211.         if (cur_mode>0)    *(pcode+(*plen)++) = 0;
  212.         break;
  213.       case 6: /* BEZIER x1 y1 x2 y2 x3 y3 */
  214.         get_xy();
  215.         get_xy();
  216.         get_xy();
  217.         no_more();
  218.         break;
  219.       case 7 :    /* box x y  [left | center | right]  [fill xxx] name*/
  220.         get_xy();
  221.         get_optional(op_box);
  222.         break;
  223.       case 52: /* call subroutine */
  224.         {
  225.             char tmpexp[232];
  226.             strcpy(tmpexp,tok(curtok++));
  227.             strcat(tmpexp,"(");
  228.             while (curtok <= *ntok) {
  229.                 strcat(tmpexp,tok(curtok++));
  230.                 strcat(tmpexp,",");
  231.             }
  232.             tmpexp[strlen(tmpexp)-1] = ')';
  233.             etype = 0;
  234.             polish(tmpexp,(char *) pcode,plen,&etype);
  235.         }
  236.         break;
  237.       case 8 :    /* circle rad fill */
  238.         get_exp();
  239.         get_optional(op_circle);
  240.         break;
  241.       case 9 : /* close */
  242.         get_exp();
  243.         no_more();
  244.         break;
  245.       case 53: /* comment !  or blank line */
  246.         break;
  247.       case 10 : /* curve sx sy x y x y x y ... ex ey */
  248.         while (*ntok>curtok) {
  249.             *(pcode+(*plen)++) = 111;
  250.             get_xy();
  251.         }
  252.         *(pcode+(*plen)++) = 999;
  253.         break;
  254.       case 60 : /* defmarker xyz rm 33 1 -.4 -.2 */
  255.         g_defmarker(tok(curtok),tok(curtok+1),atoi(tok(curtok+2))
  256.             ,atof(tok(curtok+4)),atof(tok(curtok+5))
  257.             ,atof(tok(curtok+3)),true);
  258.         break;
  259.       case 11 :  /* define marker jj subname */
  260.         get_token("MARKER");
  261.         g_marker_def(tok(curtok),tok(curtok+1));
  262.         curtok+=2;
  263.         no_more();
  264.         break;
  265.       case 12 :
  266.         sl = strlen(source)+1;
  267.         sl = ((sl + 3) & 0xfffc);
  268.         sl = sl/4;
  269.         /* copy source string to pcode., add null, round upp.      */
  270.         strcpy((char *) (pcode+*plen),source);
  271.         *plen = *plen + sl;
  272.         break;
  273.       case 13 :/* ELSE ... */
  274.         scheck(50);
  275.         no_more();
  276.         break;
  277.       case 14 : /* END if, sub, path, box, scale,translate,rotate */
  278.         i = get_optional(op_begin);
  279.         if (i==7) {
  280.             sub_end = srclin;
  281.             sub_set_startend(sdx,sub_start,sub_end);
  282.             var_clear_local();
  283.             in_sub = false;
  284.         }
  285.         if (i==0) gprint("Type of END missing, e.g. end if, end sub\n");
  286.         spop(i+50);    /* Check if begin variable matches */
  287.         break;
  288.       case 16 : /* FILL (fillpath) */
  289.         no_more();
  290.         break;
  291.       case 15 : /* FCLOSE inchan */
  292.         get_exp();
  293.         break;
  294.       case 17: /* fopen "a.a" inchan read|write */
  295.         get_strexp();
  296.         var_findadd(tok(curtok),&v,&vtyp);
  297.         curtok++;
  298.         *(pcode+(*plen)++) = v;
  299.         if (strcmp(tok(curtok),"WRITE")==0) *(pcode+(*plen)++) = 1;
  300.         else {
  301.             get_token("READ");
  302.             *(pcode+(*plen)++) = 0;
  303.         }
  304.       case 61 : /* fread CHAN a$ x   */
  305.       case 62 : /* freadln */
  306.         while (curtok<=*ntok) {
  307.             var_findadd(tok(curtok),&v,&vtyp); curtok++;
  308.             *(pcode+(*plen)++) = 49;
  309.             *(pcode+(*plen)++) = v;
  310.             *(pcode+(*plen)++) = vtyp;
  311.             skip_space;
  312.         }
  313.         break;
  314.       case 63 : /* fwrite */
  315.       case 64 : /* fwriteln */
  316.         while (curtok<=*ntok) {
  317.             *(pcode+(*plen)++) = 49;
  318.             *(pcode+(*plen)) = 0;
  319.             savep = (int *) (pcode+(*plen)++);
  320.             get_anyexp();
  321.             *savep = etype;
  322.             skip_space;
  323.         }
  324.         break;
  325.       case 18 :  /* for var = exp1 to exp2 [step exp3] */
  326.         sp = strchr(tok(curtok),'=');
  327.         if (sp!=NULL) {
  328.             *sp = 0;
  329.             var_findadd(tok(curtok),&v,&vtyp);
  330.             tok(curtok) = sp + 1;
  331.             *(pcode+(*plen)++) = v;
  332.             spush(v+100);    /* Remeber we started a loop with variable v*/
  333.         } else {
  334.             var_findadd(tok(curtok++),&v,&vtyp);
  335.             *(pcode+(*plen)++) = v;
  336.             spush(v+100);    /* Remeber we started a loop with variable v*/
  337.             get_token("=");
  338.         }
  339.         get_exp();
  340.         get_token("TO");
  341.         get_exp();
  342.         get_optional(op_for_step);
  343.         break;
  344.       case 19 :/* goto */
  345.         gprint("Goto IS NOT implemented, being kept or a future release.\n");
  346.         break;
  347.       case 20 : /* gsave */
  348.         no_more();
  349.         break;
  350.       case 54 : /* grestore */
  351.         no_more();
  352.         break;
  353.       case 21 : /* icon x y */
  354.         get_xy();
  355.         no_more();
  356.         break;
  357.       case 22 :  /* IF exp THEN ...  */
  358.         get_exp();
  359.         get_token("THEN");
  360.         no_more();
  361.         spush(50);    /* Check if endif or else matches */
  362.         break;
  363.       case 55 : /* postscript file$  width  height */
  364.         get_strexp();
  365.         get_xy();
  366.         no_more();
  367.         break;
  368.       case 56 : /* draw file$, nope, not a good idea. begin..end text */
  369.         get_strexp();
  370.         no_more();
  371.         break;
  372.       case 57 : /* plotter fonts */
  373.         get_token("FONTS");
  374.         no_more();
  375.         break;
  376.       case 23 : /* include "string" */
  377.         include_file(tok(curtok++));
  378.         no_more();
  379.         break;
  380.       case 58 : /* bigfile "string" This waits until 'run' to read the file*/
  381.         get_strexp();
  382.         no_more();
  383.         break;
  384.       case 24 : /* input 1 a$=20,fill$=10,j=6 prompt "Age and name " */
  385.               /* input 1 a$,yval prompt "Age and name " */
  386.       case 25 : /* join a.tl->b.br   ,   string, arrows&line, string */
  387.         get_strexp();
  388.         *(pcode+(*plen)++) = get_first(op_joinname);
  389.         get_strexp();
  390.         break;
  391.       case 26 : /* marker square [2.2] */
  392.         get_marker(tk,ntok,&curtok,pcode,plen);
  393.         if (*ntok<curtok) {
  394.             *(pcode+(*plen)++) = 0;
  395.         } else {
  396.             get_exp();
  397.         }
  398.         break;
  399.       case 27 : /* MOVE name */
  400.         get_strexp();
  401.         no_more();
  402.         break;
  403.       case 28 : /* Arc in clockwise direction */
  404.         get_exp();
  405.         get_xy();
  406.         no_more();
  407.         break;
  408.       case 29 : /* newpath */
  409.         no_more();
  410.         break;
  411.       case 30 : /* next */
  412.         if (curtok<=*ntok) get_exp();
  413.         spop(v+100);    /* Check if loop variable matches */
  414.         no_more();
  415.         break;
  416.       case 31 : /* pie r a1 a2 fill pattern */
  417.         get_exp();
  418.         get_xy();
  419.         get_optional(op_fill);
  420.         break;
  421.       case 32 : /*print 0 "Working..." */
  422.       case 33 :
  423.         get_xy();
  424.         get_xy();
  425.         get_xy();
  426.         no_more();
  427.         break;
  428.       case 34 : /* region */
  429.         gprint("Region IS NOT implemented, complain to your local MP   \n");
  430.         break;
  431.       case 50 : /* Return EXP */
  432.         get_exp();
  433.         break;
  434.       case 35 : /* Reverse the current path */
  435.         no_more();
  436.         break;
  437.       case 36 : /* rline */
  438.         get_xy();
  439.         get_optional(op_line);
  440.         break;
  441.       case 37 : /* rmove */
  442.         get_xy();
  443.         no_more();
  444.         break;
  445.       case 38 : /* rotate */
  446.         get_exp();
  447.         no_more();
  448.         break;
  449.       case 39 : /* save joe */
  450.         get_strexp();
  451.         no_more();
  452.         break;
  453.       case 40 : /* scale x y */
  454.         get_xy();
  455.         no_more();
  456.         break;
  457.       case 41 : /* SET color font hei just lwidth lstyle ldist */
  458.         while (curtok<=*ntok) {
  459.          dbg gprint(" set ntok= %d  curtok= %d \n",curtok,*ntok);
  460.          f = get_first(op_set);
  461.          *(pcode+(*plen)++) = 500+f;
  462.          switch (f) {
  463.           case 1: /* height */
  464.             get_exp();
  465.             break;
  466.           case 2: /* font */
  467.             get_font(tk,ntok,&curtok,pcode,plen);
  468.             break;
  469.           case 3: /* justify */
  470.             get_justify(tk,ntok,&curtok,pcode,plen);
  471.             break;
  472.           case 4: /* color */
  473.             get_color(tk,ntok,&curtok,pcode,plen);
  474.             break;
  475.           case 5: /* dashlen */
  476.             get_exp();
  477.             break;
  478.           case 6: /* dash */
  479.             get_exp();
  480.             break;
  481.           case 7: /* lwidth */
  482.             get_exp();
  483.             break;
  484.           case 8: /* join */
  485.             /* get_join(); */
  486.             get_join(tk,ntok,&curtok,pcode,plen);
  487.             break;
  488.           case 9: /* cap */
  489.             /* get_cap(); */
  490.             get_cap(tk,ntok,&curtok,pcode,plen);
  491.             break;
  492.           case 10: /* fontlwidth */
  493.             get_exp();
  494.             break;
  495.           }
  496.         }
  497.         break;
  498.       case 42 : /* size */
  499.         get_xy();
  500.         get_optional(op_size);
  501.         break;
  502.       case 43 : /* STROKE */
  503.         no_more();
  504.         break;
  505.       case 44 : /* SUB JOE X Y$ Z   ... END SUB  */
  506.         if (in_sub) {gprint("Cannot define a subroutine within a sub "); break;}
  507.         in_sub = true;
  508.         spush(51);        /* to check structure */
  509.         sdx = sub_def(tok(curtok++));
  510.         var_set_local();
  511.         if (!valid_var(psub->name)) {
  512.             gprint("Invalid subroutine name ");
  513.         }
  514.         for (np=0; curtok<=*ntok; np++) {
  515.             sub_param(sdx,tok(curtok));
  516.             if (!valid_var(tok(curtok))) {
  517.                 gprint("Invalid subroutine parameter");
  518.             }
  519.             curtok++;
  520.         }
  521.         *(pcode+(*plen)++) = sdx; /* put sub number in pcode */
  522.         sub_start = srclin;
  523.         var_set_global();
  524.         break;
  525.       case 45 :
  526.         /* char *source;    a pointer to the original string */
  527.         /* produce captilized string                 */
  528.         for (i=0; *(source+i)!=0; i++)
  529.             tempstr[i] = toupper(*(source+i));
  530.         /* find word TEXT                      */
  531.         sp = strstr(tempstr,"TEXT");
  532.         if (sp==NULL) {gprint("what the shit \n"); break;}
  533.                         /* sp = &tempstr;    */
  534.         sp = (sp-&tempstr[0])+source;    /* switch to lowercase str */
  535.         sp = sp + 5;
  536.         sl = strlen(sp)+1;
  537.         sl = ((sl + 3) & 0xfffc);
  538.         sl = sl/4;
  539.         /* copy rest of string to pcode., add null, round upp.      */
  540.         strcpy((char *) (pcode+*plen),sp);
  541.         *plen = *plen + sl;
  542.         break;
  543.       case 59 : /* textdef */
  544.         /* char *source;    a pointer to the original string */
  545.         /* produce captilized string                 */
  546.         for (i=0; *(source+i)!=0; i++)
  547.             tempstr[i] = toupper(*(source+i));
  548.         /* find word TEXT                      */
  549.         sp = strstr(tempstr,"TEXTDEF");
  550.         if (sp==NULL) {gprint("what the shit \n"); break;}
  551.                         /* sp = &tempstr;    */
  552.         sp = (sp-&tempstr[0])+source;    /* switch to lowercase str */
  553.         sp = sp + 8;
  554.         sl = strlen(sp)+1;
  555.         sl = ((sl + 3) & 0xfffc);
  556.         sl = sl/4;
  557.         /* copy rest of string to pcode., add null, round upp.      */
  558.         strcpy((char *) (pcode+*plen),sp);
  559.         *plen = *plen + sl;
  560.         break;
  561.       case 46 : /* translate x y */
  562.         get_xy();
  563.         no_more();
  564.         break;
  565.       case 47 : /* until */
  566.         get_exp();
  567.         spush(50+20);
  568.         break;
  569.       case 48 : /* while */
  570.         gprint("While IS NOT implemented, complain to your local MP   \n");
  571.         break;
  572.       case 49 : /* write numexp,strexp,strexp */
  573.         while (curtok<=*ntok) {
  574.             *(pcode+(*plen)++) = 49;
  575.             *(pcode+(*plen)) = 0;
  576.             savep = (int *) (pcode+(*plen)++);
  577.             get_anyexp();
  578.             *savep = etype;
  579.             skip_space;
  580.         }
  581.         break;
  582.       default:
  583.         gprint("Unrecognised command verb {%s}   %d \n",tok(1),ix);
  584.         if (strchr(tok(1),'=')!=NULL)
  585.             gprint("There should be a space on either side of an equals sign \n");
  586.  
  587.     }
  588. return;
  589.  
  590. /*------------*/
  591. text_mode: /* Inside a begin, don't interpret, just pass "as is" */
  592.     *(pcode+(*plen)++) = 5;        /* begin */
  593.     if (strcmp(tok(1),"END")==0) {
  594.       i = gt_index((OPKEY) op_begin,tok(2));
  595.       if (i==cur_mode) {
  596.         *(pcode+(*plen)++) = 0;        /* END XXXX */
  597.         cur_mode = 0;
  598.         return;
  599.       }
  600.     }
  601.     *(pcode+(*plen)++) = cur_mode;    /* begin_type (e.g. text, graph, xaxis */
  602.  
  603.     sl = strlen(source)+1;
  604.     *(pcode+*plen) = 0;
  605.     sl = ((sl + 3) & 0xfffc);
  606.     sl = sl/4;
  607.     /* copy source string to pcode., add null, round upp.      */
  608.     strcpy((char *) (pcode+*plen),source);
  609.     *plen = *plen + sl;
  610. }
  611. /*--------------------------------------------------------------------------*/
  612. gt_xy(int *curtok, char (*(*tk)[500]), int *ntok,
  613.     long *pcode, int *plen)
  614. {
  615.     int etype;
  616.     etype = 1;
  617.     if (*ntok < *curtok) {
  618.         gprint("Expecting x expression on end of line\n");
  619.     }
  620.     polish(tok((*curtok)++),(char *) pcode,plen,&etype);
  621.     etype = 1;
  622.     if (*ntok < *curtok) {
  623.         gprint("Expecting y expression on end of line\n");
  624.     }
  625.     polish(tok((*curtok)++),(char *) pcode,plen,&etype);
  626. }
  627. /*--------------------------------------------------------------------------*/
  628. long gt_first(OPKEY lkey, int *curtok, TOKENS tk, int *ntok, long *pcode, int *plen)
  629. {
  630.     int nk,i,width=0,p;
  631.     for (i=0; (*lkey)[i].typ!=typ_end; i++) {
  632.         p = (*lkey)[i].pos;
  633.         if (p>width) width = p ;
  634.     }
  635.     nk = i;
  636.     for (i=0; i<nk; i++) {
  637.         if (strcmp((*lkey)[i].name,tok(*curtok))==0) {
  638.             (*curtok)++;
  639.             return (*lkey)[i].idx;
  640.         }
  641.     }
  642.     gprint("Found {%s} expecting one of: \n",tok(*curtok));
  643.     gprint("        ");
  644.     for (i=0; i<nk; i++) {
  645.         gprint("%s, ",(*lkey)[i].name);
  646.         if ( (i+1)/3 == (i+1)/3.0 ) gprint("\n        ");
  647.     }
  648.     if ( (i)/3 != (i+1)/3.0 ) gprint("\n");
  649.     (*curtok)++;
  650.  
  651. }
  652. long gt_firstval(OPKEY lkey,char *s)
  653. {
  654.     int nk,i,width=0,p;
  655.     for (i=0; (*lkey)[i].typ!=typ_end; i++) {
  656.         p = (*lkey)[i].pos;
  657.         if (p>width) width = p ;
  658.     }
  659.     nk = i;
  660.     for (i=0; i<nk; i++) {
  661.         if (strcmp((*lkey)[i].name,s)==0) {
  662.             dbg gprint("Got match {%s} \n",s);
  663.             return (*lkey)[i].idx;
  664.         }
  665.     }
  666.     gprint("Found {%s} expecting one of: \n",s);
  667.     for (i=0; i<nk; i++) gprint("        %s \n",(*lkey)[i].name);
  668. }
  669.  
  670. long gt_index(OPKEY lkey,char *s)
  671. {
  672.     int nk,i,p;
  673.     for (i=0; (*lkey)[i].typ!=typ_end; i++) {
  674.         if (strcmp((*lkey)[i].name,s)==0) {
  675.             return (*lkey)[i].idx;
  676.         }
  677.     }
  678.     return 0;
  679. }
  680. /*--------------------------------------------------------------------------*/
  681. gt_optional(OPKEY lkey, int *curtok, TOKENS tk, int *ntok, long *pcode, int *plen)
  682. {
  683.     int rval=0;
  684.     int xlen,*pt;
  685.     int etype,f;
  686.     int nk,i,width=0,p,tt,pidx,prest;
  687.  
  688.     for (i=0; (*lkey)[i].typ!=typ_end; i++) {
  689.         p = (*lkey)[i].pos;
  690.         if (p>width) width = p ;
  691.     }
  692.     nk = i;
  693.     /* zero all the optional parameters. */
  694.     for (i=0; i<width; i++) {
  695.         *(pcode + i + *plen) = 0;
  696.     }
  697.     dbg gprint("The number of flags %d first token {%s} %d \n",nk,tok(*curtok),*curtok);
  698.     prest = *plen + nk;    /*remeber where the END OF exp'S are */
  699.     for (tt = *curtok; tt<= *ntok; ) {
  700.       for (i=0; i<nk; i++) {
  701.         if (strcmp((*lkey)[i].name,tok(tt))==0) {
  702.             tt++;
  703.             goto found_word;
  704.         }
  705.       }
  706.     *plen = prest;
  707.       gprint("Found {%s} (%d) expecting one of: \n",tok(tt),tt);
  708.       for (i=0; i<nk; i++) gprint("        %s \n",(*lkey)[i].name);
  709.       *curtok = tt;
  710.       return 0;
  711. found_word:
  712. /*----------------------------------------*/
  713. /* switches     int     placed in directly, 1 present, 0 not present
  714. /* expressions     LONG*     pointed to, 0 if not present.
  715. /* color/fill    LONG*     Pointer to exp 0 if not present.
  716. /* marker    LONG*    Pointer to exp 0 if not present.
  717. /* lstyle     LONG*    Pointer to exp 0 if not present.
  718. /* font     long*     Pointer to string expression.
  719. /* justify     long
  720. */
  721.  
  722.       switch ((*lkey)[i].typ) {
  723.         case typ_val:
  724.         etype = 1;
  725.         pt = (int *)  (pcode + *plen + (*lkey)[i].pos - 1);
  726.         if (*pt!=0) gprint("Duplicate or illegal combination of qualifiers ");
  727.         *pt = prest-*plen-(*lkey)[i].pos+1;
  728.         polish(tok(tt++),(char *) pcode,&prest,&etype);
  729.         dbg gprint("val Returned,  curtok=%d prest=%d type %d \n",tt,prest,etype);
  730.          break;
  731.         case typ_val2:
  732.         etype = 1;
  733.         pt = (int *) (pcode + *plen + (*lkey)[i].pos - 1);
  734.         if (*pt!=0) gprint("Duplicate or illegal combination of qualifiers ");
  735.         *pt = prest-*plen-(*lkey)[i].pos+1 ;
  736.         polish(tok(tt++),(char *) pcode,&prest,&etype);
  737.         dbg gprint("val Returned,  curtok=%d prest=%d type %d \n",tt,prest,etype);
  738.         tt++;    /* step over space between expressions */
  739.         etype = 1;
  740.         pt = pt + 1;
  741.         if (*pt!=0) gprint("Duplicate or illegal combination of qualifiers ");
  742.         *pt = prest-*plen-(*lkey)[i].pos+1 ;
  743.         polish(tok(tt++),(char *) pcode,&prest,&etype);
  744.         dbg gprint("val Returned,  curtok=%d prest=%d type %d \n",tt,prest,etype);
  745.         break;
  746.         case typ_str: /* string constant,  used for NAMEs, */
  747.         etype = 2;
  748.         pt = (int *) (pcode + *plen + (*lkey)[i].pos - 1);
  749.         if (*pt!=0) gprint("Duplicate or illegal combination of qualifiers %ld %p \n",*pt,pt);
  750.         *pt = prest-*plen-(*lkey)[i].pos+1;
  751.         polish(tok(tt++),(char *) pcode,&prest,&etype);
  752.          break;
  753.         case typ_switch:
  754.         pt = (int *) (pcode + *plen + (*lkey)[i].pos - 1);
  755.         dup_err;
  756.         *pt = (*lkey)[i].idx;
  757.         rval = *pt;
  758.         break;
  759.         case typ_color: /* blue green red, or exp. */
  760.         case typ_fill:
  761.         pt = (int *) lkeypos(i);
  762.         dup_err;
  763.         *pt = prest-*plen-(*lkey)[i].pos+1 ;
  764.         get_fill(tk,ntok,&tt,pcode,&prest);
  765.         break;
  766.         case typ_marker:
  767.         pt = (int *) lkeypos(i);
  768.         dup_err;
  769.         *pt = prest-*plen-(*lkey)[i].pos+1 ;
  770.         get_marker(tk,ntok,&tt,pcode,&prest);
  771.         break;
  772.         case typ_lstyle:
  773.         pt = (int *) lkeypos(i);
  774.         dup_err;
  775.         *pt = prest-*plen-(*lkey)[i].pos+1 ;
  776.         etype = 1;
  777.         polish(tok(tt++),(char *) pcode,&prest,&etype);
  778.         break;
  779.         case typ_justify:
  780.         pt = (int *) lkeypos(i);
  781.         dup_err;
  782.         *pt = gt_first((OPKEY) op_justify,&tt,(TOKENS) tk,ntok,pcode,&prest);
  783.         dbg gprint("setting justify flag %d \n",*pt);
  784.         break;
  785.         case typ_arrow:
  786.         f = gt_first((OPKEY) op_arrow,&tt,(TOKENS) tk,ntok,pcode,&prest);
  787.         pt = (int *) lkeypos(i);
  788.         *pt = f;
  789.         break;
  790.         default :
  791.         gprint("***errrorororororor non existent type ***");
  792.         break;
  793.       }
  794. /*----------------------------------------*/
  795.     }
  796.     *plen = prest;
  797.     *curtok = tt;
  798.     return rval;
  799. }
  800. /*--------------------------------------------------------------------------*/
  801.  
  802. #undef get_first
  803. #define get_first(key) gt_first(&key,curtok,tk,ntok,pcode,plen)
  804.  
  805. /*--------------------------------------------------------------------------*/
  806. mystrcpy(char **d,char *s)
  807. {
  808.     if (*d!=0) myfree(*d);
  809.     *d = 0;
  810.     *d = myallocz(strlen(s)+1);
  811.     strcpy(*d,s);
  812. }
  813.  
  814. #define get_exp() polish(tok((*curtok)++),(char *) pcode,plen,&etype)
  815. /* pos=   Offset to find the data            */
  816. /* idx=   For switches, which can only have one value.     */
  817. /*--------------------------------------------------------------------------*/
  818. int pass_justify(char *s)
  819. {
  820.     return gt_firstval((OPKEY) op_justify,s);
  821. }
  822. int polish_eval(char *s, double *x);
  823. long pass_color(char *s)
  824. {
  825.     double xx;
  826.     long j;
  827.     int i;
  828.     char vv[80];
  829.     if (strstr(s,"CVTRGB")!=NULL) {
  830.         polish_eval(s,&xx);
  831.     } else if (*s=='.' || *s=='(' || isdigit(*s)) {
  832.         strcpy(vv,"cvtgrey(");
  833.         strcat(vv,s); strcat(vv,")");
  834.         polish_eval(vv,&xx);
  835.     } else    if (strchr(s,'$') != NULL) {
  836.         strcpy(vv,"cvtcolor(");
  837.         strcat(vv,s); strcat(vv,")");
  838.         polish_eval(vv,&xx);
  839.     } else {
  840.         return     gt_firstval((OPKEY) op_color_typ,s);
  841.     }
  842.     memcpy(&j,&xx,sizeof(long));
  843.     return j;
  844. }
  845. #define get_exps(ss) polish(ss,(char *) pcode,plen,&etype)
  846. get_color(TOKENS tk,int *ntok,int *curtok,long *pcode,int *plen)
  847. {
  848.     int i,etype=1;
  849.     char vv[80];
  850.  
  851.     if (strstr(tok(*curtok),"CVTRGB")!=NULL) {
  852.         get_exps(tok(*curtok));
  853.     } else if (*tok(*curtok)=='(' || isdigit(*tok(*curtok))) {
  854.         strcpy(vv,"cvtgrey(");
  855.         strcat(vv,tok(*curtok)); strcat(vv,")");
  856.         get_exps(vv);
  857.     } else    if (strchr(tok(*curtok),'$') != NULL) {
  858.         strcpy(vv,"cvtcolor(");
  859.         strcat(vv,tok(*curtok)); strcat(vv,")");
  860.         get_exps(vv);
  861.     } else {
  862.         *(pcode+(*plen)++) = 8;
  863.         *(pcode+(*plen)++) = get_first(op_color_typ);
  864.         return;
  865.     }
  866.     (*curtok)++;
  867. }
  868. get_fill(TOKENS tk,int *ntok,int *curtok,long *pcode,int *plen)
  869. {
  870.     int i,etype=1;
  871.     char vv[80];
  872.     if (strstr(tok(*curtok),"CVTRGB")!=NULL) {
  873.         get_exps(tok(*curtok));
  874.     } else if (*tok(*curtok)=='(' || isdigit(*tok(*curtok))) {
  875.         strcpy(vv,"cvtgrey(");
  876.         strcat(vv,tok(*curtok)); strcat(vv,")");
  877.         get_exps(vv);
  878.     } else    if (strchr(tok(*curtok),'$') != NULL) {
  879.         strcpy(vv,"cvtcolor(");
  880.         strcat(vv,tok(*curtok)); strcat(vv,")");
  881.         get_exps(vv);
  882.     } else {
  883.         *(pcode+(*plen)++) = 8;
  884.         *(pcode+(*plen)++) = get_first(op_color_typ);
  885.         return;
  886.     }
  887.     (*curtok)++;
  888. }
  889. get_justify(TOKENS tk,int *ntok,int *curtok,long *pcode,int *plen)
  890. {
  891.     *(pcode+(*plen)++) = get_first(op_justify);
  892. }
  893. get_join(TOKENS tk,int *ntok,int *curtok,long *pcode,int *plen)
  894. {
  895.     *(pcode+(*plen)++) = get_first(op_join);
  896. }
  897. get_cap(TOKENS tk,int *ntok,int *curtok,long *pcode,int *plen)
  898. {
  899.     *(pcode+(*plen)++) = get_first(op_cap);
  900. }
  901.  
  902. struct mark_struct { char *name; char *font; int cc; double rx; double ry; double scl;};
  903. struct mark_struct stdmark[] = {
  904.         "DOT","RM",46,-.125,-.0435,3.0,    /* dot */
  905.         "CROSS","TEXSY",2,-.375,-.24,1.0,    /* cross */
  906.         "FCIRCLE","GLEMARK",4,-.5,-.5,0.7,    /* fcircle */
  907.         "FSQUARE","GLEMARK",6,-.5,-.5,0.7,    /* fsquare */
  908.         "FTRIANGLE","GLEMARK",5,-.5,-.433,0.7,    /* ftriangle */
  909.         "FDIAMOND","GLEMARK",7,-.5,-.7,0.7,    /* fdiamond */
  910.         "CIRCLE","GLEMARK",12,-.5,-.5,0.7,    /* circle */
  911.         "SQUARE","GLEMARK",2,-.5,-.5,0.7,    /* square */
  912.         "TRIANGLE","GLEMARK",1,-.5,-.433,0.7,    /* triangle */
  913.         "DIAMOND","GLEMARK",3,-.5,-.7,0.7,    /* diamond */
  914.         "PLUS","TEXMI",43,-.375,-.24,1.0,    /* plus  (needs fixing ) */
  915.         "CLUB","TEXSY",124,-.38,-.3,1.0,    /* club */
  916.         "HEART","TEXSY",126,-.38,-.34,1.0,    /* heart */
  917.         "DIAMONDZ","TEXSY",125,-.38,-.26,1.0,    /* diamondz */
  918.         "SPADE","TEXSY",127,-.375,-.24,1.0,    /* spade (needs fixing) */
  919.         "STAR","TEXMI",63,-.25,-.21,1.0,    /* star */
  920.         "SNAKE","TEXSY",120,-.21,-.22,1.0,    /* snake */
  921.         "DAG","TEXSY",121,-.21,-.22,1.0,    /* dag */
  922.         "DDAG","TEXSY",122,-.21,-.22,1.0,    /* dagg */
  923.         "ASTERIX","TEXSY",3,-.25,-.24,1.0,    /* asterix */
  924.         "ASTERISK","TEXSY",3,-.25,-.24,1.0,    /* asterix */
  925.         "OPLUS","TEXSY",8,-.40,-.24,1.0,    /* oplus */
  926.         "OMINUS","TEXSY",9,-.40,-.24,1.0,    /* ominus */
  927.         "OTIMES","TEXSY",10,-.40,-.24,1.0,    /* otimes */
  928.         "ODOT","TEXSY",12,-.40,-.24,1.0,    /* odot */
  929.         "TRIANGLEZ","TEXSY",52,-.44,-.26,1.0,    /* trianglez */
  930.         "DIAMONDZ","TEXSY",125,-.38,-.26,1.0,    /* diamondz */
  931.         "WCIRCLE","GLEMARK",8,-.5,-.5,0.7,    /* wcircle */
  932.         "WTRIANGLE","GLEMARK",9,-.5,-.433,0.7,    /* wtriangle */
  933.         "WSQUARE","GLEMARK",10,-.5,-.5,0.7,    /* wsquare */
  934.         "WDIAMOND","GLEMARK",11,-.5,-.7,0.7,    /* wdiamond */
  935.         "PLANE","PSZD",40,0.0,0.0,1.0,        /* ZapDingbats */
  936.         "HANDPEN","PSZD",45,0.0,0.0,1.0,    /* ZapDingbats */
  937.         "SCIRCLE","PSZD",109,0.0,0.0,1.0,    /* ZapDingbats */
  938.         "SSQUARE","PSZD",111,0.0,0.0,1.0,    /* ZapDingbats */
  939.         "PHONE","PSZD",37,0.0,0.0,1.0,        /* ZapDingbats */
  940.         "LETTER","PSZD",41,0.0,0.0,1.0,        /* ZapDingbats */
  941.         "STAR2","PSZD",69,0.0,0.0,1.0,        /* ZapDingbats */
  942.         "STAR3","PSZD",79,0.0,0.0,1.0,        /* ZapDingbats */
  943.         "STAR4","PSZD",98,0.0,0.0,1.0,        /* ZapDingbats */
  944.         "FLOWER","PSZD",96,0.0,0.0,1.0,        /* ZapDingbats */
  945.         NULL,NULL,0,0,0,0
  946. };    /* change range check below when adding markers */
  947.  
  948.  
  949.  
  950. char *mark_name[30];
  951. char *mrk_fname[61];
  952. char *mrk_name[61];
  953. char *mark_sub[30];
  954. int mark_subp[30];
  955. int nmark;
  956. int nmrk;
  957. int std_nmrk;
  958. mark_clear()
  959. {
  960.     int i,fg;
  961.     struct mark_struct *p;
  962.     if (std_nmrk==0) {
  963.         for (i=0; stdmark[i].name !=NULL; i++) {
  964.             p = &stdmark[i];
  965.             fg = false;
  966.             if (p->rx==0) fg = true;
  967.             g_defmarker(p->name,p->font,p->cc,p->rx,p->ry
  968.                 ,p->scl,fg);
  969.         }
  970.         std_nmrk = nmrk;
  971.     }
  972.     for (i=0; i<nmark; i++) {
  973.       if (mark_sub[i]!=NULL) { myfree(mark_sub[i]); mark_sub[i]=NULL;}
  974.       if (mark_name[i]!=NULL) { myfree(mark_name[i]); mark_name[i]=NULL;}
  975.     }
  976.     for (i=std_nmrk; i<nmrk; i++) {
  977.       if (mrk_name[i]!=NULL) { myfree(mrk_name[i]); mrk_name[i]=NULL;}
  978.       if (mrk_fname[i]!=NULL) { myfree(mrk_fname[i]); mrk_fname[i]=NULL;}
  979.     }
  980.     nmrk = std_nmrk;
  981.     nmark = 0;
  982. }
  983. get_marker(TOKENS tk,int *ntok,int *curtok,long *pcode,int *plen)
  984. {
  985.     int i,etype=1;
  986.     char vv[80];
  987.     if (*tok(*curtok)=='(' || isdigit(*tok(*curtok))) {
  988.         strcpy(vv,"cvtint(");
  989.         strcat(vv,tok(*curtok)); strcat(vv,")");
  990.         get_exps(vv);
  991.     } else    if (strchr(tok(*curtok),'$') != NULL) {
  992.         strcpy(vv,"cvtmarker(");
  993.         strcat(vv,tok(*curtok)); strcat(vv,")");
  994.         get_exps(vv);
  995.     } else {
  996.         *(pcode+(*plen)++) = 8;
  997.         *(pcode+(*plen)++) = pass_marker(tok(*curtok));
  998.     }
  999.     (*curtok)++;
  1000. }
  1001. pass_marker(char *s)
  1002. {
  1003.     int i;
  1004.     long f=0;
  1005.     /* if 0, maybe its a user defined marker, ie a subroutine */
  1006.     /* Use -ve to signify subroutine instead of normal marker */
  1007.     for (i=0; i<nmark; i++) {
  1008.         if (strcmp(mark_name[i],s)==0) {
  1009.             f = -(++i);
  1010.             break;
  1011.         }
  1012.     }
  1013.     if (f==0)  {
  1014.         for (i=nmrk-1; i>=0; i--) {
  1015.             if (strcmp(mrk_name[i],s)==0) {
  1016.                 f = ++i;
  1017.                 break;
  1018.             }
  1019.         }
  1020.     }
  1021.     if (f==0) gprint("Invalid marker name {%s} \n",s);
  1022.     return f;
  1023. }
  1024.  
  1025.  
  1026. spop(int v)
  1027. {
  1028. }
  1029. spush(int v)
  1030. {
  1031. }
  1032. scheck(int v)
  1033. {
  1034. }
  1035.  
  1036.  
  1037.  
  1038.  
  1039.  
  1040.